import { queryDictModelByCode } from '@/api/index'
import moment from "moment/moment";
//校验必填项
export const verifcatMandatory = (info, mandatory) => {
  let verifcations = []
  Object.keys(mandatory).map((item) => {
    //判断当前数据是对象还是普通字符串
    if (typeof mandatory[item] == 'string') {
      if (info[item] == '' || info[item] == null) {
        verifcations.push(mandatory[item])
      }
    }
    //对象
    else {
      if (info[item] == '' || info[item] == null) {
        if (item == 'pollutantTypes') {
          verifcations.push('主要污染物种类')
        } else if (item == 'gasOrganization') {
          verifcations.push('废气排放方式')
        } else {
          verifcations.push(mandatory[item].name)
        }
      } else {
        let _mandatory = mandatory[item]
        //判断是否为数组  _mandatory instanceof Array == false
        if (!Array.isArray(_mandatory)) {
          _mandatory = [_mandatory]
        }
        _mandatory.map((items) => {
          if (
            info[item].split(',').indexOf(items.type.toString()) >= 0 ||
            (items.type instanceof Array && items.type.indexOf(Number(info[item])) >= 0)
          ) {
            verifcations.push(...verifcatMandatory(info, items.child))
          }
        })
      }
    }
  })

  return verifcations
}

export const nativePlusToast = (content) => {
  //#ifdef APP-PLUS
  plus.nativeUI.toast(content)
  //#endif
}

/**
 * 通过字典编码查询字典值，批量回显的示例如下
 * const tripDictKeys = [
 *   {
 *     dictCode: 'reimbursement_content',
 *     fieldKey: 'feeType',
 *     insertField: 'feeTypeDictText'
 *   }
 * ]
 * this.tripData.forEach((item, index) => {
 *   Promise.allSettled(tripDictKeys.map(i => (
 *     this.$utils.queryDictByCode(i.dictCode, item[i.fieldKey])
 *       .then(text => {
 *         this.$set(this.tripData[index], i.insertField, text)
 *       })
 *   )))
 * })
 * @param {String} dictCode 字典编码
 * @param {String} id 字典 value
 * @param {String} text 字典 text
 * @returns {String} text
 */
export const queryDictByCode = (dictCode, id, text = 'text') => {
  return queryDictModelByCode({
    dictCode,
  })
    .then((response) => {
      if (response.success) {
        const row = response.result.find((i) => Number(i.value) === Number(id))
        return row[text]
      }
    })
    .catch((error) => error)
}

/**
 * 重复值验证工具方法
 *
 * 使用示例：
 * { validator: (rule, value, callback) => validateDuplicateValue('sys_fill_rule', 'rule_code', value, this.model.id, callback) }
 *
 * @param tableName 被验证的表名
 * @param fieldName 被验证的字段名
 * @param fieldVal 被验证的值
 * @param dataId 数据ID，可空
 * @param callback
 */
export function validateBlankValue(tableName, fieldName, fieldVal, dataId, callback) {
  if (fieldVal) {
    let v = replaceAll(fieldVal, ' ', '')
    if (!v || v.length == 0) {
      callback(fieldName + '不能为空白字符串')
    }
    fieldVal = fieldVal.trim()
    callback()
  } else {
    callback()
  }
}

export function convertCurrency(money) {
  //汉字的数字
  let cnNums = new Array('零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖')
  //基本单位
  let cnIntRadice = new Array('', '拾', '佰', '仟')
  //对应整数部分扩展单位
  let cnIntUnits = new Array('', '万', '亿', '兆')
  //对应小数部分单位
  let cnDecUnits = new Array('角', '分', '毫', '厘')
  //整数金额时后面跟的字符
  let cnInteger = '整'
  //整型完以后的单位
  let cnIntLast = '元'
  //最大处理的数字
  let maxNum = 999999999999999.9999
  //金额整数部分
  let integerNum
  //金额小数部分
  let decimalNum
  //输出的中文金额字符串
  let chineseStr = ''
  //分离金额后用的数组，预定义
  let parts
  // 传入的参数为空情况
  //let money = this.model.yjhte
  if (money == '' && money != 0) {
    return ''
  }
  money = parseFloat(money)
  if (money >= maxNum) {
    return ''
  }
  // 传入的参数为0情况
  if (money == 0) {
    chineseStr = cnNums[0] + cnIntLast + cnInteger
    return chineseStr
  }
  // 转为字符串
  money = money.toString()
  // indexOf 检测某字符在字符串中首次出现的位置 返回索引值（从0 开始） -1 代表无
  if (money.indexOf('.') == -1) {
    integerNum = money
    decimalNum = ''
  } else {
    parts = money.split('.')
    integerNum = parts[0]
    decimalNum = parts[1].substr(0, 4)
  }
  //转换整数部分
  if (parseInt(integerNum, 10) > 0) {
    let zeroCount = 0
    let IntLen = integerNum.length
    for (let i = 0; i < IntLen; i++) {
      let n = integerNum.substr(i, 1)
      let p = IntLen - i - 1
      let q = p / 4
      let m = p % 4
      if (n == '0') {
        zeroCount++
      } else {
        if (zeroCount > 0) {
          chineseStr += cnNums[0]
        }
        zeroCount = 0
        chineseStr += cnNums[parseInt(n)] + cnIntRadice[m]
      }
      if (m == 0 && zeroCount < 4) {
        chineseStr += cnIntUnits[q]
      }
    }
    // 最后+ 元
    chineseStr += cnIntLast
  }
  // 转换小数部分
  if (decimalNum != '') {
    let decLen = decimalNum.length
    for (let i = 0; i < decLen; i++) {
      let n = decimalNum.substr(i, 1)
      if (n != '0') {
        chineseStr += cnNums[Number(n)] + cnDecUnits[i]
      }
    }
  }
  if (chineseStr == '') {
    chineseStr += cnNums[0] + cnIntLast + cnInteger
  } else if (decimalNum == '') {
    chineseStr += cnInteger
  }

  return chineseStr
}
/**
 * @description toast轻提示
 * @param {String} title 文案提示
 * @param {String} icon 图标
 */
export function toast(title = "", icon = 'none') {
	uni.showToast({
		title,
		icon
	})
}

/**
 * @description dialog 提示
 * @param {String} content 文案提示
 * @param {String} title 文案标题
 */
export function uniDialog(content = '系统繁忙，请稍后再试', title = "温馨提示") {
	uni.showModal({
		title,
		content,
		showCancel: false
	})
}

/**
 * @description dialog 提示 带callback
 * @param {String} content 文案提示
 * @param {String} title 文案标题
 */
export function uniDlgCallBack({ 
	title = '温馨提示',
	content = '系统繁忙，请稍后再试',
	showCancel = true,
	cancelText = '取消',
	confirmText = '确定',
	success = () => {},
	fail = () => {},
} = {}) {
	uni.showModal({ 
		title, 
		content, 
		showCancel, 
		confirmText,
		cancelText,
		success: ({ confirm, cancel }) => {
			// console.log({ confirm, cancel })
			confirm && success()
			cancel && fail()
		}
	})
}
export function uniqueByKey(array, key) {
  const seen = new Set();
  return array.filter((item) => {
    const keyValue = item[key];
    if (seen.has(keyValue)) {
      return false;
    } else {
      seen.add(keyValue);
      return true;
    }
  });
}
// 用来根据当天时间获取当天所在周的周一至周日
// 直接返回周一会有问题，因为在英文环境中，默认上周日是这周的开始，所以得计算
// 下面这个方法会将时间定位至0时0分0秒0毫秒，不这样设置的话会变成当前的时间
function getThisWeeksMondayAtMidnight(myFormat) {
    let now = moment();
    let diff = now.isoWeekday() - 1; // 计算当前日期与本周一的差值
    if (diff > 0) {
        // 如果当前不是周一，则向前移动到周一
        now.add(-diff, 'days');
    }
    // 显式地将时间设置为午夜
    now.hours(0).minutes(0).seconds(0).milliseconds(0);
    // 格式化日期时间字符串
    return now.format(myFormat);
}
export function getCurrentWeekStartAndEndInCST(myFormat) {
    // 获取当前UTC时间，并设置UTC偏移量为东八区
    // 注意：这里实际上并没有太大意义，因为moment()默认就是本地时间
    // 但如果你确实想从UTC开始并加上偏移量，可以这样做
    let now = moment().utcOffset('+0800');
    // let now = moment();
		myFormat = myFormat?'YYYY-MM-DD':myFormat
    let startOfWeek = getThisWeeksMondayAtMidnight(myFormat)

    // 计算本周周日的日期和时间（假设周日是一周的结束，但这里实际上需要额外处理）
    // 因为endOf('week')默认会到周日的23:59:59.999，所以你可能想要周日的00:00:00
    // let endOfWeek = now.clone().endOf('week').subtract(1, 'millisecond').format('YYYY-MM-DD HH:mm:ss');
    // 或者，如果你想要的是周日当天的开始时间（即周日00:00:00）
    let endOfWeek = now.clone().startOf('isoWeek').add(6, 'days').format(myFormat);

    // 返回结果
    return {
        startOfWeek: startOfWeek,
        endOfWeek: endOfWeek
    };
}
